{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "name": "overfit_and_underfit.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "toc_visible": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    }
  },
  "cells": [
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "# Introduction to Overfit and Underfit\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "### Learning objectives\n",
      "\n",
      "1. Use the Higgs Dataset.\n",
      "2. Demonstrate overfitting.\n",
      "3. Strategies to prevent overfitting.\n",
      "\n",
      "## Introduction \n",
      "\n",
      "In this notebook, we'll explore several common regularization techniques, and use them to improve on a classification model.\n",
      "\n",
      "As always, the code in this example will use the `tf.keras` API, which you can learn more about in the TensorFlow [Keras guide](https://www.tensorflow.org/guide/keras).\n",
      "\n",
      "In both of the previous examples—[classifying text](https://www.tensorflow.org/tutorials/keras/text_classification_with_hub) and [predicting fuel efficiency](https://www.tensorflow.org/tutorials/keras/regression) — we saw that the accuracy of our model on the validation data would peak after training for a number of epochs, and would then stagnate or start decreasing.\n",
      "\n",
      "In other words, our model would *overfit* to the training data. Learning how to deal with overfitting is important. Although it's often possible to achieve high accuracy on the *training set*, what we really want is to develop models that generalize well to a *testing set* (or data they haven't seen before).\n",
      "\n",
      "The opposite of overfitting is *underfitting*. Underfitting occurs when there is still room for improvement on the train data. This can happen for a number of reasons: If the model is not powerful enough, is over-regularized, or has simply not been trained long enough. This means the network has not learned the relevant patterns in the training data.\n",
      "\n",
      "If you train for too long though, the model will start to overfit and learn patterns from the training data that don't generalize to the test data. We need to strike a balance. Understanding how to train for an appropriate number of epochs as we'll explore below is a useful skill.\n",
      "\n",
      "To prevent overfitting, the best solution is to use more complete training data. The dataset should cover the full range of inputs that the model is expected to handle. Additional data may only be useful if it covers new and interesting cases.\n",
      "\n",
      "A model trained on more complete data will naturally generalize better. When that is no longer possible, the next best solution is to use techniques like regularization. These place constraints on the quantity and type of information your model can store.  If a network can only afford to memorize a small number of patterns, the optimization process will force it to focus on the most prominent patterns, which have a better chance of generalizing well.\n",
      "\n",
      "Each learning objective will correspond to a __#TODO__ in the [student lab notebook](../labs/overfit_and_underfit.ipynb) -- try to complete that notebook first before reviewing this solution notebook."
     ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WL8UoOTmGGsL"
      },
      "source": [
        "## Setup"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9FklhSI0Gg9R"
      },
      "source": [
        "Before getting started, import the necessary packages:"
      ]
    },
    {
     "cell_type": "code",
     "execution_count": 3,
     "metadata": {},
     "outputs": [
      {
       "name": "stdout",
       "output_type": "stream",
       "text": [
        "Collecting tensorflow==2.7.0\n",
        "  Downloading tensorflow-2.7.0-cp37-cp37m-manylinux2010_x86_64.whl (454.3 MB)\n",
        "\u001b[K     |████████████████████████████▍   | 402.9 MB 84.1 MB/s eta 0:00:013"
       ]
      },
      {
       "name": "stderr",
       "output_type": "stream",
       "text": [
        "IOPub data rate exceeded.\n",
        "The Jupyter server will temporarily stop sending output\n",
        "to the client in order to avoid crashing it.\n",
        "To change this limit, set the config variable\n",
        "`--ServerApp.iopub_data_rate_limit`.\n",
        "\n",
        "Current values:\n",
        "ServerApp.iopub_data_rate_limit=1000000.0 (bytes/sec)\n",
        "ServerApp.rate_limit_window=3.0 (secs)\n",
        "\n"
       ]
      },
      {
       "name": "stdout",
       "output_type": "stream",
       "text": [
        "\u001b[K     |████████████████████████████████| 454.3 MB 11 kB/s \n",
        "\u001b[?25hRequirement already satisfied: typing-extensions~=3.7.4 in /opt/conda/lib/python3.7/site-packages (from tensorflow==2.7.0) (3.7.4.3)\n",
        ".\n",
        ".\n",
        ".\n",
        ".\n",
        "  Attempting uninstall: grpcio\n",
        "    Found existing installation: grpcio 1.38.1\n",
        "    Uninstalling grpcio-1.38.1:\n",
        "      Successfully uninstalled grpcio-1.38.1\n",
        "  Attempting uninstall: tensorflow-estimator\n",
        "Successfully installed grpcio-1.34.1 keras-nightly-2.7.0.dev2021032900 tensorflow-2.7.0 tensorflow-estimator-2.7.0\n"
       ]
      }
     ],
     "source": [
      "!pip install tensorflow==2.7.0"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "id": "m7KBpffWzlxH"
    },
    "source": [
     "**NOTE**: Please ignore any incompatibility warnings and errors.\n"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "id": "m7KBpffWzlxH"
    },
    "source": [
     "**NOTE**: Restart your kernel to use updated packages.\n"
     ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5pZ8A2liqvgk",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1fd8cb0a-93af-4e53-a574-a93ab4b5ba00"
      },
      "source": [
        "import tensorflow as tf\n",
        "\n",
        "from tensorflow.keras import layers\n",
        "from tensorflow.keras import regularizers\n",
        "\n",
        "print(tf.__version__)"
      ],
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2.7.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QnAtAjqRYVXe",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "16b3372b-85f3-4c8a-92ba-61f182a52c21"
      },
      "source": [
        "!pip install git+https://github.com/tensorflow/docs\n",
        "\n",
        "import tensorflow_docs as tfdocs\n",
        "import tensorflow_docs.modeling\n",
        "import tensorflow_docs.plots"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Collecting git+https://github.com/tensorflow/docs\n",
            "  Cloning https://github.com/tensorflow/docs to /tmp/pip-req-build-oqwcq2pv\n",
            "  Running command git clone -q https://github.com/tensorflow/docs /tmp/pip-req-build-oqwcq2pv\n",
            "Requirement already satisfied: astor in /usr/local/lib/python3.7/dist-packages (from tensorflow-docs==0.0.0.dev0) (0.8.1)\n",
            "Requirement already satisfied: absl-py in /usr/local/lib/python3.7/dist-packages (from tensorflow-docs==0.0.0.dev0) (0.12.0)\n",
            "Requirement already satisfied: protobuf>=3.14 in /usr/local/lib/python3.7/dist-packages (from tensorflow-docs==0.0.0.dev0) (3.17.3)\n",
            "Requirement already satisfied: pyyaml in /usr/local/lib/python3.7/dist-packages (from tensorflow-docs==0.0.0.dev0) (3.13)\n",
            "Requirement already satisfied: six>=1.9 in /usr/local/lib/python3.7/dist-packages (from protobuf>=3.14->tensorflow-docs==0.0.0.dev0) (1.15.0)\n",
            "Building wheels for collected packages: tensorflow-docs\n",
            "  Building wheel for tensorflow-docs (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
            "  Created wheel for tensorflow-docs: filename=tensorflow_docs-0.0.0.dev0-py3-none-any.whl size=157855 sha256=d85beece717779a49328a8fbedfaee0ce7c31e036ee40208d2bb65cba3b2171b\n",
            "  Stored in directory: /tmp/pip-ephem-wheel-cache-lzrh2slb/wheels/cc/c4/d8/5341e93b6376c5c929c49469fce21155eb69cef1a4da4ce32c\n",
            "Successfully built tensorflow-docs\n",
            "Installing collected packages: tensorflow-docs\n",
            "Successfully installed tensorflow-docs-0.0.0.dev0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-pnOU-ctX27Q"
      },
      "source": [
        "from  IPython import display\n",
        "from matplotlib import pyplot as plt\n",
        "\n",
        "import numpy as np\n",
        "\n",
        "import pathlib\n",
        "import shutil\n",
        "import tempfile\n"
      ],
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jj6I4dvTtbUe"
      },
      "source": [
        "logdir = pathlib.Path(tempfile.mkdtemp())/\"tensorboard_logs\"\n",
        "shutil.rmtree(logdir, ignore_errors=True)"
      ],
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1cweoTiruj8O"
      },
      "source": [
        "## The Higgs Dataset\n",
        "\n",
        "The goal of this tutorial is not to do particle physics, so don't dwell on the details of the dataset. It contains 11&#x202F;000&#x202F;000 examples, each with 28 features, and a binary class label."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YPjAvwb-6dFd",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "bbd9ab11-0a53-47bd-cc58-508536bf4ad5"
      },
      "source": [
        "# TODO \n",
        "# Downloads a file from a URL if it not already in the cache\n",
        "gz = tf.keras.utils.get_file('HIGGS.csv.gz', 'http://mlphysics.ics.uci.edu/data/higgs/HIGGS.csv.gz')"
      ],
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Downloading data from http://mlphysics.ics.uci.edu/data/higgs/HIGGS.csv.gz\n",
            "2816409600/2816407858 [==============================] - 50s 0us/step\n",
            "2816417792/2816407858 [==============================] - 50s 0us/step\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AkiyUdaWIrww"
      },
      "source": [
        "FEATURES = 28"
      ],
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SFggl9gYKKRJ"
      },
      "source": [
        "The `tf.data.experimental.CsvDataset` class can be used to read csv records directly from a gzip file with no intermediate decompression step."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QHz4sLVQEVIU"
      },
      "source": [
        "# A Dataset comprising lines from one or more CSV files.\n",
        "ds = tf.data.experimental.CsvDataset(gz,[float(),]*(FEATURES+1), compression_type=\"GZIP\")"
      ],
      "execution_count": 7,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HzahEELTKlSV"
      },
      "source": [
        "That csv reader class returns a list of scalars for each record. The following function repacks that list of scalars into a (feature_vector, label) pair."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zPD6ICDlF6Wf"
      },
      "source": [
        "def pack_row(*row):\n",
        "  label = row[0]\n",
        "  features = tf.stack(row[1:],1)\n",
        "  return features, label"
      ],
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4oa8tLuwLsbO"
      },
      "source": [
        "TensorFlow is most efficient when operating on large batches of data.\n",
        "\n",
        "So instead of repacking each row individually make a new `Dataset` that takes batches of 10000-examples, applies the `pack_row` function to each batch, and then splits the batches back up into individual records:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-w-VHTwwGVoZ"
      },
      "source": [
        "packed_ds = ds.batch(10000).map(pack_row).unbatch()"
      ],
      "execution_count": 9,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lUbxc5bxNSXV"
      },
      "source": [
        "Have a look at some of the records from this new `packed_ds`.\n",
        "\n",
        "The features are not perfectly normalized, but this is sufficient for this tutorial."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TfcXuv33Fvka",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 367
        },
        "outputId": "61279513-5c3f-4d1b-cda4-268724d3363d"
      },
      "source": [
        "for features,label in packed_ds.batch(1000).take(1):\n",
        "  print(features[0])\n",
        "  plt.hist(features.numpy().flatten(), bins = 101)"
      ],
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tf.Tensor(\n",
            "[ 0.8692932  -0.6350818   0.22569026  0.32747006 -0.6899932   0.75420225\n",
            " -0.24857314 -1.0920639   0.          1.3749921  -0.6536742   0.9303491\n",
            "  1.1074361   1.1389043  -1.5781983  -1.0469854   0.          0.65792954\n",
            " -0.01045457 -0.04576717  3.1019614   1.35376     0.9795631   0.97807616\n",
            "  0.92000484  0.72165745  0.98875093  0.87667835], shape=(28,), dtype=float32)\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ICKZRY7gN-QM"
      },
      "source": [
        "To keep this tutorial relatively short use just the first 1000 samples for validation, and the next 10 000 for training:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hmk49OqZIFZP"
      },
      "source": [
        "N_VALIDATION = int(1e3)\n",
        "N_TRAIN = int(1e4)\n",
        "BUFFER_SIZE = int(1e4)\n",
        "BATCH_SIZE = 500\n",
        "STEPS_PER_EPOCH = N_TRAIN//BATCH_SIZE"
      ],
      "execution_count": 11,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FP3M9DmvON32"
      },
      "source": [
        "The `Dataset.skip` and `Dataset.take` methods make this easy.\n",
        "\n",
        "At the same time, use the `Dataset.cache` method to ensure that the loader doesn't need to re-read the data from the file on each epoch:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "H8H_ZzpBOOk-"
      },
      "source": [
        "# Creates a Dataset with at most count elements from this dataset.\n",
        "# Creates a Dataset that skips count elements from this dataset.\n",
        "validate_ds = packed_ds.take(N_VALIDATION).cache()\n",
        "train_ds = packed_ds.skip(N_VALIDATION).take(N_TRAIN).cache()"
      ],
      "execution_count": 12,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9zAOqk2_Px7K",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d9416707-3a36-4603-cde9-4004e3eed1a2"
      },
      "source": [
        "train_ds"
      ],
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<CacheDataset shapes: ((28,), ()), types: (tf.float32, tf.float32)>"
            ]
          },
          "metadata": {},
          "execution_count": 13
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6PMliHoVO3OL"
      },
      "source": [
        "These datasets return individual examples. Use the `.batch` method to create batches of an appropriate size for training. Before batching also remember to `.shuffle` and `.repeat` the training set."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Y7I4J355O223"
      },
      "source": [
        "validate_ds = validate_ds.batch(BATCH_SIZE)\n",
        "train_ds = train_ds.shuffle(BUFFER_SIZE).repeat().batch(BATCH_SIZE)"
      ],
      "execution_count": 14,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lglk41MwvU5o"
      },
      "source": [
        "## Demonstrate overfitting\n",
        "\n",
        "The simplest way to prevent overfitting is to start with a small model: A model with a small number of learnable parameters (which is determined by the number of layers and the number of units per layer). In deep learning, the number of learnable parameters in a model is often referred to as the model's \"capacity\".\n",
        "\n",
        "Intuitively, a model with more parameters will have more \"memorization capacity\" and therefore will be able to easily learn a perfect dictionary-like mapping between training samples and their targets, a mapping without any generalization power, but this would be useless when making predictions on previously unseen data.\n",
        "\n",
        "Always keep this in mind: deep learning models tend to be good at fitting to the training data, but the real challenge is generalization, not fitting.\n",
        "\n",
        "On the other hand, if the network has limited memorization resources, it will not be able to learn the mapping as easily. To minimize its loss, it will have to learn compressed representations that have more predictive power. At the same time, if you make your model too small, it will have difficulty fitting to the training data. There is a balance between \"too much capacity\" and \"not enough capacity\".\n",
        "\n",
        "Unfortunately, there is no magical formula to determine the right size or architecture of your model (in terms of the number of layers, or the right size for each layer). You will have to experiment using a series of different architectures.\n",
        "\n",
        "To find an appropriate model size, it's best to start with relatively few layers and parameters, then begin increasing the size of the layers or adding new layers until you see diminishing returns on the validation loss.\n",
        "\n",
        "Start with a simple model using only `layers.Dense` as a baseline, then create larger versions, and compare them."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_ReKHdC2EgVu"
      },
      "source": [
        "### Training procedure"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pNzkSkkXSP5l"
      },
      "source": [
        "Many models train better if you gradually reduce the learning rate during training. Use `optimizers.schedules` to reduce the learning rate over time:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LwQp-ERhAD6F"
      },
      "source": [
        "# TODO\n",
        "# A LearningRateSchedule that uses an inverse time decay schedule\n",
        "lr_schedule = tf.keras.optimizers.schedules.InverseTimeDecay(\n",
        "  0.001,\n",
        "  decay_steps=STEPS_PER_EPOCH*1000,\n",
        "  decay_rate=1,\n",
        "  staircase=False)\n",
        "\n",
        "def get_optimizer():\n",
        "  return tf.keras.optimizers.Adam(lr_schedule)"
      ],
      "execution_count": 15,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kANLx6OYTQ8B"
      },
      "source": [
        "The code above sets a `schedules.InverseTimeDecay` to hyperbolically decrease the learning rate to 1/2 of the base rate at 1000 epochs, 1/3 at 2000 epochs and so on."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HIo_yPjEAFgn",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 388
        },
        "outputId": "20867aca-e5cc-482f-adbe-ef8d552e960a"
      },
      "source": [
        "step = np.linspace(0,100000)\n",
        "lr = lr_schedule(step)\n",
        "plt.figure(figsize = (8,6))\n",
        "plt.plot(step/STEPS_PER_EPOCH, lr)\n",
        "plt.ylim([0,max(plt.ylim())])\n",
        "plt.xlabel('Epoch')\n",
        "_ = plt.ylabel('Learning Rate')\n"
      ],
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgQAAAFzCAYAAABBzRFyAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3deXhV5bn38e+diSSQhEwESIAwBBAUHCJO1AnnamnrhLZVq62t1VNbT09fPafvaY9vz+lgW1tPtWodWq1j1Va0zuJUByAoIrNhHkMgA2NChvv9Yy9opEnYQnZWdvbvc137ytprrf3kXktDflnreZ5l7o6IiIgktqSwCxAREZHwKRCIiIiIAoGIiIgoEIiIiAgKBCIiIoICgYiIiAApYRcQpoKCAi8tLQ27DBERkW4xZ86cze5e2N62hA4EpaWlVFRUhF2GiIhItzCzVR1t0y0DERERUSAQERERBQIRERFBgUBERERQIBAREREUCERERAQFAhERESHGgcDMzjKzJWZWaWY3trO9j5k9FmyfaWalbbbdFKxfYmZntll/n5ltMrP5+7SVZ2Yvm9nHwdfcWB6biIhIbxKzQGBmycDtwNnAOOASMxu3z25XAbXuPgq4FfhZ8NlxwDRgPHAWcEfQHsAfgnX7uhF41d3LgFeD9yIiIhKFWF4hmARUuvtyd98NPApM3WefqcAfg+UngClmZsH6R9290d1XAJVBe7j7m0BNO9+vbVt/BD7flQezP62tzsb6hu78liIiIl0mloGgGFjT5v3aYF27+7h7M1AP5Ef52X0VufuGYHkjUHRgZR+Y6x55n0vvea87v6WIiEiX6ZWdCt3dAW9vm5ldbWYVZlZRXV3dZd/zqGF5LK/ewZqanV3WpoiISHeJZSBYBwxp874kWNfuPmaWAuQAW6L87L6qzGxQ0NYgYFN7O7n73e5e7u7lhYXtPvDpgJw8JtLW60va/bYiIiI9WiwDwWygzMyGm1kakU6C0/fZZzpwebB8ATAj+Ot+OjAtGIUwHCgDZu3n+7Vt63Lg6S44hqiNKOjL0LxMXlvSdVcdREREukvMAkHQJ+A64EVgEfC4uy8ws5vN7HPBbvcC+WZWCdxAMDLA3RcAjwMLgReAa929BcDMHgHeBcaY2Vozuypo66fA6Wb2MXBa8L7bmBknjynknWWbaWhq6c5vLSIictAs8gd5YiovL/eKiooua2/G4iqu/EMFD1w5iRNHd93tCBERka5gZnPcvby9bb2yU2FYjhtRQFpKEq/rtoGIiMQZBYIulJGWzDHD83h9qToWiohIfFEg6GInjxmg4YciIhJ3FAi6mIYfiohIPFIg6GJ7hh+qH4GIiMQTBYIu9o/hh1s0/FBEROKGAkEMnDymkF1NLcxa0d4zmERERHoeBYIY0PBDERGJNwoEMaDhhyIiEm8UCGJEww9FRCSeKBDEyCkafigiInFEgSBGhmv4oYiIxBEFghjR8EMREYknCgQxtGf44eyVGn4oIiI9mwJBDGn4oYiIxAsFghjaO/xQHQtFRKSHUyCIsVPGDGCZhh+KiEgPp0AQY3r6oYiIxAMFghjT8EMREYkHCgQxpuGHIiISDxQIuoGGH4qISE+nQNANNPxQRER6OgWCbqDhhyIi0tMpEHSTPcMPV23ZEXYpIiIi/0SBoJucMb4IgGfnbQi5EhERkX+mQNBNSnIzOWpYLs98uD7sUkRERP6JAkE3Om/CIBZv3MbHVdvCLkVEROQTFAi60TkTBpFk8IxuG4iISA+jQNCNBmSlc+yIfJ79cD3uHnY5IiIieykQdLPzJg5m+eYdLFi/NexSRERE9lIg6GZnjR9ISpLxzDx1LhQRkZ5DgaCb5fZN4zNlBTz74QbdNhARkR5DgSAE500czLq6Xby/ui7sUkRERAAFglCcPq6ItJQkzUkgIiI9hgJBCLLSUzl1zAD+9tEGWlp120BERMKnQBCS8yYOpnpbIzNXbAm7FBEREQWCsJw6dgCZacm6bSAiIj2CAkFIMtKSOX1cEc/P38ju5tawyxERkQSnQBCi8yYMpm5nE29Xbg67FBERSXAKBCE6cXQh2ekpum0gIiKhUyAIUVpKEmcfOoiXFlbR0NQSdjkiIpLAFAhCdt7EwWxvbOb1JZvCLkVERBKYAkHIjh2RR0G/NJ75UI9EFhGR8CgQhCwlOYlzDhvEq4ur2N7YHHY5IiKSoBQIeoDzJg6moamVVxdVhV2KiIgkKAWCHuCoobkMyknXaAMREQmNAkEPkJRknDthEG8sraZ+Z1PY5YiISAJSIOghzps4mKYW57n56lwoIiLdT4GghzisOIfRRf14ZNbqsEsREZEEpEDQQ5gZXzpmGPPW1jNvbV3Y5YiISIJRIOhBvnBkMRmpyTz0nq4SiIhI91Ig6EGy01OZevhgpn+4nvpd6lwoIiLdR4Ggh/nSMcPY1dTCXz9YF3YpIiKSQBQIepjDSnKYUJLDn95bhbuHXY6IiCSImAYCMzvLzJaYWaWZ3djO9j5m9liwfaaZlbbZdlOwfomZnbm/Ns1sipm9b2ZzzezvZjYqlscWS18+Zhgfb9rO7JW1YZciIiIJImaBwMySgduBs4FxwCVmNm6f3a4Cat19FHAr8LPgs+OAacB44CzgDjNL3k+bvwO+5O6HAw8DP4jVscXauRMHkZWewkMzV4VdioiIJIhYXiGYBFS6+3J33w08CkzdZ5+pwB+D5SeAKWZmwfpH3b3R3VcAlUF7nbXpQHawnAPE7TzAmWkpnH9kCc9/tJEt2xvDLkdERBJALANBMbCmzfu1wbp293H3ZqAeyO/ks521+TXgOTNbC3wF+Gl7RZnZ1WZWYWYV1dXVB3BY3eNLxwxld0srf56zNuxSREQkAfSmToXfBc5x9xLgfuBX7e3k7ne7e7m7lxcWFnZrgZ9GWVEWk4bn8fDM1bS2qnOhiIjEViwDwTpgSJv3JcG6dvcxsxQil/q3dPLZdtebWSEw0d1nBusfA47vmsMIz5ePHcbqmp28Vbk57FJERKSXi2UgmA2UmdlwM0sj0klw+j77TAcuD5YvAGZ4ZKzddGBaMAphOFAGzOqkzVogx8xGB22dDiyK4bF1izPHF5HfN42H3lPnQhERia2UWDXs7s1mdh3wIpAM3OfuC8zsZqDC3acD9wIPmlklUEPkFzzBfo8DC4Fm4Fp3bwFor81g/deBJ82slUhAuDJWx9Zd+qQkc9HRQ7j7zeVsqN/FoJyMsEsSEZFeyhJ58pvy8nKvqKgIu4xOrd6yk5N+8RrfPrWM754+ev8fEBER6YCZzXH38va29aZOhb3S0PxMTiwr5NHZq2luaQ27HBER6aUUCOLAl48dRtXWRl5dvCnsUkREpJdSIIgDp4wpZFBOOn9S50IREYkRBYI4kJKcxCWThvLWx5tZtWVH2OWIiEgvpEAQJy4+egjJScZDM1eHXYqIiPRCCgRxoig7nbMOHcgjM1eztaEp7HJERKSXUSCII9ecNJJtjc08+K76EoiISNdSIIgjhxbncPKYQu77+wp27W4JuxwREelFFAjizLWnjGLLjt08Nlt9CUREpOsoEMSZo0vzmFSax91vLmd3syYqEhGRrqFAEIe+dcpI1tc38Ne5+z48UkRE5MAoEMShk0YXMn5wNne+voyW1sR9FoWIiHQdBYI4ZGZce8oolm/ewQvzN4ZdjoiI9AIKBHHqzPEDGVHYl9tfqySRn1gpIiJdQ4EgTiUnGdecNJKFG7by+tLqsMsREZE4p0AQxz5/RDHF/TO447XKsEsREZE4p0AQx1KTk7j6xBHMXlnLrBU1YZcjIiJxTIEgzl189BAK+qVxu64SiIjIQVAgiHPpqclcOXk4byytZv66+rDLERGROKVA0At85dhhZKWncMfrukogIiIHRoGgF8hKT+WK40t5fv5GKjdtD7scERGJQwoEvcRXTxhOekoyd76xLOxSREQkDikQ9BJ5fdO4ZNJQ/vLBOpZV6yqBiIh8OgoEvci3ThlJRmoyP39hcdiliIhInFEg6EUK+vXhmyeN4MUFVcxeqXkJREQkegoEvcxVk0cwMDud//7bIj3jQEREoqZA0MtkpCVzwxmjmbumjr99tCHsckREJE4oEPRC5x9ZwtiBWfz8hSU0NreEXY6IiMQBBYJeKDnJuOmcQ1hds5M/vbc67HJERCQOKBD0UieNLuQzZQX874yPqd/VFHY5IiLSwykQ9GI3nX0I9bua9HhkERHZLwWCXmzc4GzOP7KE+99ZyZqanWGXIyIiPZgCQS/3r2eMJsngFy8tCbsUERHpwRQIerlBORlcNXk4T89dz7y1dWGXIyIiPZQCQQL45kkjye+bxv88p8mKRESkfQoECSArPZXrTyvjveU1zFi8KexyRESkB1IgSBCXTBrKiIK+/OT5xTS3tIZdjoiI9DAKBAkiNTmJ7581lspN23ng3VVhlyMiIj2MAkECOXN8ESePKeQXLy1hXd2usMsREZEeRIEggZgZ/2/qobjDD5+erw6GIiKylwJBghmSl8kNp4/mlUWbeGH+xrDLERGRHkKBIAF99YRSxg/O5ofTF7C1Qc85EBERBYKElJKcxE++eBibtzfy8xcWh12OiIj0AAoECWpCSX+uOH44f3pvNXNW1YRdjoiIhEyBIIH96xmjKe6fwU1PfcTuZs1NICKSyBQIEljfPincPHU8S6u2c/eby8IuR0REQqRAkOCmHFLEZw8bxG0zKllevT3sckREJCQKBMIPzxtHn5Qk/uMvmptARCRRKRAIA7LTufHssby7fAtPzFkbdjkiIhKC/QYCMxttZq+a2fzg/QQz+0HsS5PudMnRQykflst/P7eILdsbwy5HRES6WTRXCH4P3AQ0Abj7PGBaLIuS7peUZPzki4exo7GZ/6tpjUVEEk40gSDT3Wfts645FsVIuMqKsvju6aN57qON/Fm3DkREEko0gWCzmY0EHMDMLgA2xLQqCc03ThzJcSPy+dH0BazYvCPsckREpJtEEwiuBe4CxprZOuA7wDejadzMzjKzJWZWaWY3trO9j5k9FmyfaWalbbbdFKxfYmZn7q9Ni/hvM1tqZovM7NvR1CiflJxk/OriiaQmJ3H9ox9owiIRkQQRTSBwdz8NKATGuvvkaD5nZsnA7cDZwDjgEjMbt89uVwG17j4KuBX4WfDZcUT6KYwHzgLuMLPk/bR5BTAkqPEQ4NEojk3aMSgng5+dfxjz1tbzq5eXhl2OiIh0g2gCwZMA7r7D3bcF656I4nOTgEp3X+7uu4n8gp66zz5TgT+2aXOKmVmw/lF3b3T3FUBl0F5nbV4D3OzurUG9m6KoUTpw1qGDuGTSEO56cxnvVG4OuxwREYmxDgOBmY01s/OBHDP7YpvXFUB6FG0XA2vavF8brGt3H3dvBuqB/E4+21mbI4GLzazCzJ43s7IoapRO/N9zxzG8oC/ffXwutTt2h12OiIjEUGdXCMYA5wL9gfPavI4Evh770j61PkCDu5cTGSp5X3s7mdnVQWioqK6u7tYC401mWgq3TTuCmh27ufGpeRqKKCLSi6V0tMHdnwaeNrPj3P3dA2h7HZF7+nuUBOva22etmaUAOcCW/Xy2o/VrgaeC5b8A97dXlLvfDdwNUF5ert9w+3FocQ7/duYY/ue5xTwyaw2XHjM07JJERCQGoulD8IGZXWtmd5jZfXteUXxuNlBmZsPNLI1IJ8Hp++wzHbg8WL4AmOGRP0OnA9OCUQjDgTJg1n7a/CtwSrB8EqDecF3ka5NHMHlUATc/u4DKTXoAkohIbxRNIHgQGAicCbxB5K/ybZ1+gr19Aq4DXgQWAY+7+wIzu9nMPhfsdi+Qb2aVwA3AjcFnFwCPAwuBF4Br3b2lozaDtn4KnG9mHwE/Ab4WxbFJFJKSjF9eNJGM1GSuf/QDGptbwi5JRES6mO3vvrCZfeDuR5jZPHefYGapwFvufmz3lBg75eXlXlFREXYZcePlhVV8/YEKvjZ5OD84d98RpCIi0tOZ2Zygr90/ieYKQVPwtc7MDiVyn39AVxUn8eP0cUVcdtww7vn7Cp75cH3Y5YiISBeKJhDcbWa5wA+I3K9fSDCBkCSeH3x2HOXDcvm3Jz5kwfr6sMsREZEust9A4O73uHutu7/p7iPcfQDwfDfUJj1QWkoSd3z5SPpnpHH1A3Oo0fwEIiK9QqeBwMyOM7MLzGxA8H6CmT0MvN0t1UmPNCArnbu+chTV2xu59qH3aWrR8w5EROJdZzMV3kJkcp/zgb+Z2Y+Bl4CZRIYBSgKbOKQ/P/nCYby7fAv/89yisMsREZGD1OHERMBngSPcvSHoQ7AGONTdV3ZLZdLjnX9UCQvWb+W+t1cwfnAOFxxVEnZJIiJygDq7ZdDg7g0A7l4LfKwwIPv693PGcvzIfP79Lx8xd01d2OWIiMgB6iwQjDCz6XtewPB93ouQkpzEby89kgFZffjmg3PYtK0h7JJEROQAdDgxkZmd1NkH3f2NmFTUjTQxUddZuH4r5//uHcYNzuaRrx9LWko0I1pFRKQ7dTYxUWcPN4r7X/jSfcYNzuaWCydw3cMf8MPpC/ifLxyKmYVdloiIRKmzToUin8q5EwazcP1W7nh9GcPyM/nmSSPDLklERKKkQCBd6ntnjGFN7S5++vxiCvv14XyNPBARiQsKBNKlkpKMX1w4gZodjXz/yXnk9UvjlDF69IWISE+3355fZvZM29EFwetBM7vezNK7o0iJL31Skrnzy0dxyKAsvvWn9/lgdW3YJYmIyH5E0xV8ObAd+H3w2gpsA0YH70X+SVZ6KvdfMYkB2X248g+zWVa9PeySRESkE9EEguPd/VJ3fyZ4fRk42t2vBY6McX0Sxwqz+vDAlZNITjIuu3cWVVs1R4GISE8VTSDoZ2ZD97wJlvsFb/WoO+nUsPy+/OGrk6jbuZvL75tF/a6msEsSEZF2RBMI/hX4u5m9ZmavA28B3zOzvsAfY1mc9A6HFudw11fKWVa9na8/UEFDU0vYJYmIyD72Gwjc/TkiTzf8DnA9MMbd/+buO9z917EuUHqHyWUF/PKiw5m1oobvPDqXltb2Z8gUEZFwRDu/7FHAeGAicJGZXRa7kqS3+tzEwfznueN4YcFG/u2JDxUKRER6kP3OQ2BmDwIjgbnAnmu9DjwQw7qkl7py8nC2Nzbzq5eXgsMtF04kOUlTHIuIhC2aiYnKgXHe0VOQRD6lb08pw4BfvrwUUCgQEekJogkE84GBwIYY1yIJ5F+mlGEGv3hpKQ78QqFARCRU0QSCAmChmc0CGvesdPfPxawqSQjXnVqGmXHLi0todeeXF04kJVmPTRYRCUM0geBHsS5CEte1p4wC4JYXl+AOv7pIoUBEJAz7DQTu/kZ3FCKJ69pTRmEGP39hCQ7cqlAgItLtOgwEZvZ3d59sZtuIjCrYuwlwd8+OeXWSML518iiSzPjp84sBhQIRke7WYSBw98nB16zuK0cS2TdPGokBP3l+Mc0trdx68eGkpyaHXZaISEKIpg8BZpYMFLXd391Xx6ooSVzfOGkkKclJ/L9nF1KzYxZ3X1ZOTkZq2GWJiPR6+70ma2b/AlQBLwN/C17PxrguSWBXTR7Ob6Ydzvura7n4rnf1lEQRkW4QzU3aPc8vGO/uhwWvCbEuTBLb1MOLuf+KSayp2ckX73iHyk3bwy5JRKRXiyYQrAHqY12IyL4mlxXw2DeOo7G5hQvufIf3V9eGXZKISK8VTSBYDrxuZjeZ2Q17XrEuTAQij05+8prj6Z+RyqW/f49XF1WFXZKISK8UTSBYTaT/QBqQ1eYl0i2G5ffliWuOZ3RRFlc/OIfHZ68JuyQRkV6n01EGweiC0e7+pW6qR6RdBf368MjXj+Wah97n+0/Oo2prA9edOgozPf9ARKQrdHqFwN1bgGFmltZN9Yh0qG+fFO65rJwvHlHML19eyncem0tDU8v+PygiIvsVzTwEy4G3zWw6sGPPSnf/VcyqEulAWkoSv7xoIiMH9OMXLy1hefUO7r7sKAblZIRdmohIXIumD8EyIvMOJKE+BNIDmBnXnjKK33+lnBWbd3De/77NnFU1YZclIhLXzN33v1cvVV5e7hUVFWGXIQfh46ptfO2BCjbUNfDjzx/KRUcPCbskEZEey8zmuHt5e9uimamw0MxuMbPnzGzGnlfXlyny6ZUVZfH0tScwaXge339yHv/1zAKaW1rDLktEJO5Ec8vgIWAxMBz4L2AlMDuGNYl8Kv0z0/jDV4/myhOGc//bK7ni/tnU7dwddlkiInElmkCQ7+73Ak3u/oa7XwmcGuO6RD6VlOQk/vO8cfz8ggnMWlHD1NvfZuH6rWGXJSISN6IJBE3B1w1m9lkzOwLIi2FNIgfsovIhPHL1seza3cLn73ibP723ikTuJyMiEq1oAsGPzSwH+Ffge8A9wHdjWpXIQThqWC7PX/8Zjh2Rzw/+Op/rHvmAbQ1N+/+giEgC0ygDjTLotVpbnTvfXMYvX1pKSW4Gt196JIcW54RdlohIaA52lMFoM3vVzOYH7yeY2Q+6ukiRrpaUZHzr5FE8evWx7G5u5Yt3vMMf31mpWwgiIu2I5pbB74GbCPoSuPs8YFosixLpSkeX5vHctz/D5LICfjh9Adf86X3qd+kWgohIW9EEgkx3n7XPuuZYFCMSK7l907jnsnL+/ZyxvLKois/e9hbvr64NuywRkR4jmkCw2cxGAg5gZhcAG2JalUgMJCUZV584kse/eRzucMHv3uGWFxfT2KwHJImIRBMIrgXuAsaa2TrgO8A3Y1qVSAwdOTSX57/zGc4/soTbX1vG1N9qzgIRkf0GAndf7u6nAYXAWHefDHwh5pWJxFB2eiq3XDiRey4rZ/P23Uy9/e/c/lqlpj0WkYQVzRUCANx9h7tvC97eEKN6RLrVaeOKeOm7J3L6uCJueXEJF971Lsurt4ddlohIt4s6EOzDurQKkRDl9U3j9kuP5DfTDmd59Q7Oue0t/vD2ClpbNTxRRBLHgQYC/UspvYqZMfXwYl767okcMzyfHz2zkEvveU9XC0QkYXQYCMxsm5ltbee1DRgcTeNmdpaZLTGzSjO7sZ3tfczssWD7TDMrbbPtpmD9EjM781O0eZuZ6V9xOSBF2en84atH85MvHsaC9Vs569dv8ZtXPtZIBBHp9ToMBO6e5e7Z7byy3D1lfw2bWTJwO3A2MA64xMzG7bPbVUCtu48CbgV+Fnx2HJHJj8YDZwF3mFny/to0s3IgN+qjF2mHmXHJpKG8esNJnD6+iFtfWcpnb/s7s1bUhF2aiEjMHOgtg2hMAiqDUQq7gUeBqfvsMxX4Y7D8BDDFzCxY/6i7N7r7CqAyaK/DNoOwcAvw/RgekySQAdnp3H7pkdx/xdHs2t3CRXe9y41PzqNu5+6wSxMR6XKxDATFwJo279cG69rdx92bgXogv5PPdtbmdcB0d9ekSdKlThk7gJdvOJGrTxzBn+es5bRfvcHTc9fpmQgi0qvEMhB0GzMbDFwI/G8U+15tZhVmVlFdXR374qRXyExL4d/POYTp151Acf8Mrn90LpfdN4vKTequIiK9QywDwTpgSJv3JcG6dvcxsxQgB9jSyWc7Wn8EMAqoNLOVQKaZVbZXlLvf7e7l7l5eWFh4YEcmCWv84Bye+tYJ/Oi8ccxdXcdZv36THz+7UA9LEpG4F8tAMBsoM7PhZpZGpJPg9H32mQ5cHixfAMzwyHXY6cC0YBTCcKAMmNVRm+7+N3cf6O6l7l4K7Aw6Kop0ueQk44oThjPjeydzwVEl3Pv2Ck79xes8Mms1LZq7QETiVMwCQdAn4DrgRWAR8Li7LzCzm83sc8Fu9wL5wV/zNwA3Bp9dADwOLAReAK5195aO2ozVMYh0pjCrDz89fwLPXDeZEYV9uempj/jcbzUaQUTikyVyx6jy8nKvqKgIuwzpBdydZ+dt4CfPLWJ9fQPnThjETeccQnH/jLBLExHZy8zmuHt5e9v2O5+AiOyfmXHexMGcdkgRd76xjDvfWMYri6q4avJwvnHSSLLTU8MuUUSkU71ilIFIT5GRlsx3Tx/NjO+dzBnjBnL7a8s48eev8fs3l9PQpNkORaTnUiAQiYHi/hncdskRPPsvk5lQ0p//fm4Rp/7idf5csUYdD0WkR1IgEImhQ4tzeODKSTz89WMozOrDvz0xj7N/8yYvL6zSxEYi0qMoEIh0g+NHFvDXa0/gd186kuYW5+sPVHDhne8yc/mWsEsTEQE0ykCjDKTbNbe08njFWn79ylI2bWvk2BF5XD9lNMeNzA+7NBHp5TobZaBAoEAgIWloauHhmau5841lbNrWyDHD87j+tDKOG5FP5BlfIiJdS4GgAwoE0hM0NLXwyKzV/O71SDCYVJrHd04r47iRCgYi0rUUCDqgQCA9SUNTC4/NXsPvXl/Gxq0NHF2ay7enlDF5VIGCgYh0CQWCDigQSE/U0NTC4xVruOO1SDA4rDiHb5w0grPGDyQlWf2AReTAKRB0QIFAerLG5hb+8v467n5zOcs372BoXiZf/8xwLiwfQnpqctjliUgcUiDogAKBxIPWVuelhVXc+cYy5q6pI79vGpcfX8plxw2jf2Za2OWJSBxRIOiAAoHEE3dn1ooa7npzOTMWbyIzLZmLjx7CV48fztD8zLDLE5E4oEDQAQUCiVdLNm7jrjeXMX3uelrcmTK2iCtPKNXIBBHplAJBBxQIJN5trG/goZmreGjmamp27GZMURZXnFDK5w8vJiNN/QxE5JMUCDqgQCC9RUNTC898uJ77317Jwg1b6Z+ZyrSjh/KV44ZR3D8j7PJEpIdQIOiAAoH0Nnv6GfzhnZW8uGAjAKcdUsSXjh3GZ0YVkJSk2wkiiayzQJDS3cWISOyYGceMyOeYEfmsrd3Jg++t4omKtby0sIoheRlMO3ooF5UPoTCrT9ilikgPoysEukIgvVxjcwsvLqji4ZmreG95DSlJxpnjB3LpMUM5bkS+rhqIJBDdMuiAAoEkmspN23lk1mqefH8tdTubKM3PZNqkoXzxiGIGZKeHXZ6IxJgCQQcUCCRRNTS18Pz8DTw8czWzV9aSnGScNLqQC2zeXnwAABSpSURBVI8qYcohRaSlaIpkkd5IfQhE5BPSU5P5whElfOGIEpZVb+eJOWt56v21zFi8idzMVKYeXsyF5SWMH5wTdqki0k10hUBXCEQAaG5p5a3KzTxRsZaXF1axu6WVcYOyueCoEs6bOFgdEUV6Ad0y6IACgUj7anfsZvqH63lizlo+WldPcpJxwqgCPn/4YM4YP5B+fXRxUSQeKRB0QIFAZP+WVm3jrx+s4+m561lXt4v01CROHzeQzx8+mBNHF5KqRzKLxA0Fgg4oEIhEr7XVmbO6lqfnruNv8zZQu7OJ3MxUPjthEOdOGMzRpXkkawijSI+mQNABBQKRA7O7uZW3Pq7mr3PX8/LCjTQ0tVKY1YezDx3IZw8bRLnCgUiPpEDQAQUCkYO3o7GZGYs38dxHG5ixeBONzZFwcM6hAzlH4UCkR1Eg6IACgUjX2hMO/jZvA68tiYSDAVl9OHP8QM4cP5BjRuSpz4FIiBQIOqBAIBI72/eGg/W8sbSahqZWstNTmHJIEWeOL+LE0YVkpmm0gkh3UiDogAKBSPfYtbuFNz+u5qUFVby6uIq6nU30SUniM2WFnDm+iCmHFJHXNy3sMkV6Pc1UKCKhykhL3nvboLmllVkra3hpQRUvLdjIK4uqSDI4cmguUw4pYsohAygb0A8z9TsQ6U66QqArBCKhcXfmr9vKy4uqmLG4ivnrtgJQkpvBlLEDOPWQIo4dkUeflOSQKxXpHXTLoAMKBCI9y8b6BmYs3sSMxVX8vXIzDU2tZKYlM3lUASePGcBJYwop7p8RdpkicUuBoAMKBCI9V0NTC+8u28Kri6uYsWgT6+sbABg1oB8njS7kpNGFTBqeR3qqrh6IREuBoAMKBCLxwd1ZVr2d15dU88bSamauqGF3cyvpqUkcOyKfE8sKOXF0ASML1fdApDMKBB1QIBCJT7t2t/Deii28EQSEFZt3ADAwO50TRhUwuSyfE0YWMCA7PeRKRXoWjTIQkV4lIy2ZU8YM4JQxAwBYvWUnf6/czNuVm3l1cRVPvr8WgNFF/Zg8qpDJZflMGp6vpzSKdEJXCHSFQKRXaW11Fm7YujcgzFpRQ2NzK8lJxoSSHI4dkc9xI/IpL83VxEiScHTLoAMKBCK9X0NTC3NW1fLOss28t7yGD9fU0dzqpCYbE0v6RwLCyHyOGparDorS6ykQdECBQCTx7GhspmJVLe8t38K7y7bw0bp6WoKAMKGkP5OG5zGpNI+jSnPJTk8Nu1yRLqVA0AEFAhHZ1tC0NyDMXlHDvLX1NLc6ZnDIwOxIQBiex9GleRRm9Qm7XJGDokDQAQUCEdnXrt0tfLCmllkrapi9sob3V9Wxq6kFgGH5mRw1LJejhuVSPiyPsgH9SNKjnSWOaJSBiEiUMtKSOX5kAcePLACgqaWV+evqmbWihjmranlzaTVPvb8OgKz0FI4Ymkt5EBImDumvkQwSt/R/rohIJ1KTkzhiaC5HDM0FIpMkra7ZScXKWuasrmXOylpufWUp7pBkMLooi8OH9OeIof05fEguowb0I1lXESQO6JaBbhmIyEGq39XEB6trmbumjg9W1zF3TR31u5oA6NcnhQklOXsDwsSSHE2YJKHRLQMRkRjKyUjl5DEDODmYKMndWbF5Bx+sruODNZGgcOcby2lpjfwBNjA7nQklOUwc0p8JJTlMKO5PTqZGNEi4FAhERLqYmTGisB8jCvtx/lElQKSz4oL19Xy4tp55a+uYt7aelxZW7f1MaX4mE0r6c1hxDocW5zC+OFvDHqVbKRCIiHSDjLRkykvzKC/N27uufmcTH62r58O1dcxbW8fslTVM/3D93u2l+ZkcGgSEw4pzOHRwjq4kSMwoEIiIhCQnM5XJZQVMLivYu27z9kbmr6tnwfqtfLS2ng9W1/HsvA17t5fkZjBuUDbjB+cwbnA24wZnMzgnXU95lIOmQCAi0oMU9Ovzif4IALU7djN/fT0fratn4fqtLNywlZcXVbGnT3j/zFTGDcqOvAZnM3ZgNiMH9KVPiqZilugpEIiI9HC5fdP4TFkhnykr3Ltu5+5mFm3YxsINWyMhYX09D763isbmVgBSkoyRhf04ZFAWYwdlM3ZgFocMymZAVh9dTZB2KRCIiMShzLSUvbMm7tHc0srKLTtYtGEbizduZfGGbcxaUcNf5/6jX0JuZiqji7IYMzB4FWVRVpRFTob6JiQ6BQIRkV4iJTmJUQOyGDUgi/MmDt67vn5nUyQgbIwEhSUbt/HU++vY3ti8d59BOel7g0LZgH6MLspi1IB+9NXMiwkjpv+lzews4DdAMnCPu/90n+19gAeAo4AtwMXuvjLYdhNwFdACfNvdX+ysTTN7CCgHmoBZwDfcvSmWxyciEg9yMlM5ZkQ+x4zI37vO3VlXt4ulVdtYsnE7S6u2sXjjNt5dtoXdLa179yvun0FZUT/KBvSjrCgSFkYN6EeWhkT2OjELBGaWDNwOnA6sBWab2XR3X9hmt6uAWncfZWbTgJ8BF5vZOGAaMB4YDLxiZqODz3TU5kPAl4N9Hga+BvwuVscnIhLPzIyS3ExKcjM5dWzR3vXNLa2srtnJ0qrtVG7axsebtrO0ajvvLNvC7uZ/BIWi7D6MGtCPUYX9GBl8HTWgH4XqoxC3YnmFYBJQ6e7LAczsUWAq0DYQTAV+FCw/AfzWIv8nTQUedfdGYIWZVQbt0VGb7v7cnkbNbBZQEqsDExHprVKSk/ZOqgQD965vaXXW1OxkadU2Kqu3U7lpO8uqd/DkPrcestJTGFnYjxGFfSNfC/oyorAfw/IzSU/VqIeeLJaBoBhY0+b9WuCYjvZx92Yzqwfyg/Xv7fPZ4mC50zbNLBX4CnB9e0WZ2dXA1QBDhw6N/mhERBJYcpJRWtCX0oK+nNFmvbtTtbWRZUFIiASF7bxTuWXvUyEBzCJzKIwoiISF4QWRV2l+Xwb3z9ADoHqA3thb5A7gTXd/q72N7n43cDdEHm7UnYWJiPQ2ZsbAnHQG5qRzwqiCT2zb0djMis07WFa9neXVO1i+eQfLq7cza0UNu5pa9u6XlpLEsLzMf4SEICiUFmRSlJVOksJCt4hlIFgHDGnzviRY194+a80sBcgh0rmws8922KaZ/RAoBL7RBfWLiMhB6NsnZe/Uy225O5u2NbK8egcrt+xgxeZ/vF5fUv2JTo3pqUkMy+vLsPxMSguCr/l9GZqXqSsLXSyWgWA2UGZmw4n80p4GXLrPPtOBy4F3gQuAGe7uZjYdeNjMfkWkU2EZkZED1lGbZvY14Exgiru3IiIiPZKZUZSdTlF2OseNzP/EtpZWZ33dLlZt2cnKLTtYtWUHK4PlN5ZW7514CSA1OdIxckheJsPyMhmWHyznZzI0L5PMtN54ETx2Yna2gj4B1wEvEhkieJ+7LzCzm4EKd58O3As8GHQarCHyC55gv8eJdEBsBq519xaA9toMvuWdwCrg3aCH61PufnOsjk9ERLpecpIxJC/yi73tMx4AWludjVsbWLllB6u37GRVzU5W1+xk9ZadzF1dy9aG5k/sX9AvjZLcSDgYkpfBkL3LmQzKSSclOak7D63HM/fEvY1eXl7uFRUVYZchIiJdoH5nE6tqdrC6ZiertuxkbW0kMKyp2cX6ul00t/7j911ykjEoJ52S3Ixg+GUkMJTkZlCSl8nA7PReeTvCzOa4e3l723Q9RUREeoWczFQmZPZnQkn/f9rW3NLKhvoG1tTuZE0QEtbW7mRt7S7e+riaqq2Nn9g/JckY1D+d4v4ZFPfPpLh/OsW5wXJuBoP7p/e6h0cpEIiISK+Xkpy091YEI/95e2NzC+vrGvaGhDU1O1lXt4t1tbt4Z9lmNm5tYN8L6oVZfRjcP4Pi/ukMzslgcP+M4H0kMOT1TYurSZoUCEREJOH1SUneO+yxPU0trWysb2Bt7a69QWFd3U421DeweOM2ZizeRENT6z5tJjEoJ51BORkMCkLDnq8DcyJfszNSekxoUCAQERHZj9S2Vxja4e7U7mxifV0kMKzf86pvYEPdLt5dtoWqrQ207nOVITMtmYE56QzKSWdgdgaDctIpyklnUHZkbofi/hnk9k3rhiNUIBARETloZkZe3zTy+qb907wLezS3tFK9vZH1dQ1sqN/FhroGNtQ3ULU18v7dZZup2tZIS5vUMGXsAO694uhuOQYFAhERkW6QkpwUuX2QkwHktrtPS6uzeXsjG+ob2Fi/i+xufKqkAoGIiEgPkZz0j0mbGPLPoyViSbMyiIiIiAKBiIiIKBCIiIgICgQiIiKCAoGIiIigQCAiIiIoEIiIiAgKBCIiIoICgYiIiKBAICIiIigQiIiICAoEIiIiggKBiIiIoEAgIiIiKBCIiIgICgQiIiKCAoGIiIigQCAiIiIoEIiIiAgKBCIiIoICgYiIiKBAICIiIigQiIiICAoEIiIiggKBiIiIoEAgIiIiKBCIiIgICgQiIiKCAoGIiIigQCAiIiIoEIiIiAgKBCIiIoICgYiIiKBAICIiIigQiIiICAoEIiIiggKBiIiIoEAgIiIiKBCIiIgICgQiIiKCAoGIiIigQCAiIiIoEIiIiAgKBCIiIoICgYiIiKBAICIiIsQ4EJjZWWa2xMwqzezGdrb3MbPHgu0zzay0zbabgvVLzOzM/bVpZsODNiqDNtNieWwiIiK9ScwCgZklA7cDZwPjgEvMbNw+u10F1Lr7KOBW4GfBZ8cB04DxwFnAHWaWvJ82fwbcGrRVG7QtIiIiUYjlFYJJQKW7L3f33cCjwNR99pkK/DFYfgKYYmYWrH/U3RvdfQVQGbTXbpvBZ04N2iBo8/MxPDYREZFeJZaBoBhY0+b92mBdu/u4ezNQD+R38tmO1ucDdUEbHX0vERER6UBK2AV0NzO7Grg6eLvdzJZ0YfMFwOYubC8R6RwePJ3DrqHzePB0Dg9eV5/DYR1tiGUgWAcMafO+JFjX3j5rzSwFyAG27Oez7a3fAvQ3s5TgKkF73wsAd78buPtADmh/zKzC3ctj0Xai0Dk8eDqHXUPn8eDpHB687jyHsbxlMBsoC3r/pxHpJDh9n32mA5cHyxcAM9zdg/XTglEIw4EyYFZHbQafeS1og6DNp2N4bCIiIr1KzK4QuHuzmV0HvAgkA/e5+wIzuxmocPfpwL3Ag2ZWCdQQ+QVPsN/jwEKgGbjW3VsA2msz+Jb/B3jUzH4MfBC0LSIiIlGwyB/X0hXM7OrgloQcIJ3Dg6dz2DV0Hg+ezuHB685zqEAgIiIimrpYREREFAi6zP6maU5kZnafmW0ys/lt1uWZ2ctm9nHwNTdYb2Z2W3Ae55nZkW0+c3mw/8dmdnl736u3MrMhZvaamS00swVmdn2wXucxSmaWbmazzOzD4Bz+V7C+3WnPD2Rq9UQRzBz7gZk9G7zXOfwUzGylmX1kZnPNrCJYF/7PsrvrdZAvIh0clwEjgDTgQ2Bc2HX1lBdwInAkML/Nup8DNwbLNwI/C5bPAZ4HDDgWmBmszwOWB19zg+XcsI+tG8/hIODIYDkLWEpk+m6dx+jPoQH9guVUYGZwbh4HpgXr7wSuCZa/BdwZLE8DHguWxwU/432A4cHPfnLYx9fN5/IG4GHg2eC9zuGnO38rgYJ91oX+s6wrBF0jmmmaE5a7v0lkFElbbaetbjvV9FTgAY94j8j8EoOAM4GX3b3G3WuBl4k85yIhuPsGd38/WN4GLCIyG6fOY5SCc7E9eJsavJyOpz3/tFOrJwQzKwE+C9wTvO9s6nidw+iF/rOsQNA1opmmWT6pyN03BMsbgaJg+dNOW51wgsuuRxD5C1fn8VMILnXPBTYR+Qd0GR1Pe/5pp1ZPFL8Gvg+0Bu87mzpe57B9DrxkZnMsMnsu9ICf5YSbulh6Hnd3M9NwlyiYWT/gSeA77r418sdWhM7j/nlkPpPDzaw/8BdgbMglxRUzOxfY5O5zzOzksOuJY5PdfZ2ZDQBeNrPFbTeG9bOsKwRdI5ppmuWTqoLLXgRfNwXrOzqXCX+OzSyVSBh4yN2fClbrPB4Ad68jMrvpcQTTngeb2p6PvefKop9avbc7Aficma0kcmv0VOA36Bx+Ku6+Lvi6iUgwnUQP+FlWIOga0UzTLJ/UdtrqtlNNTwcuC3rWHgvUB5fRXgTOMLPcoPftGcG6hBDcd70XWOTuv2qzSecxSmZWGFwZwMwygNOJ9MXoaNrzTzu1eq/n7je5e4m7lxL5d26Gu38JncOomVlfM8vas0zkZ3A+PeFnOezelr3lRaQn6FIi9yT/I+x6etILeATYADQRuc91FZH7iK8CHwOvAHnBvgbcHpzHj4DyNu1cSaTzUSXw1bCPq5vP4WQi9x3nAXOD1zk6j5/qHE4gMq35PCL/AP9nsH4EkV9GlcCfgT7B+vTgfWWwfUSbtv4jOLdLgLPDPraQzufJ/GOUgc5h9OdtBJERFh8CC/b8vugJP8uaqVBERER0y0BEREQUCERERAQFAhEREUGBQERERFAgEBERERQIROQgmFlL8MS2Pa8ue9KnmZVamydkikhsaepiETkYu9z98LCLEJGDpysEItLlgue9/zx45vssMxsVrC81sxnBc91fNbOhwfoiM/uLmX0YvI4Pmko2s9+b2QIzeymYYVBEYkCBQEQORsY+twwubrOt3t0PA35L5Al5AP8L/NHdJwAPAbcF628D3nD3icCRRGZwg8iUtre7+3igDjg/xscjkrA0U6GIHDAz2+7u/dpZvxI41d2XBw9l2uju+Wa2GRjk7k3B+g3uXmBm1UCJuze2aaOUyPPey4L3/wdIdfcfx/7IRBKPrhCISKx4B8ufRmOb5RbU70kkZhQIRCRWLm7z9d1g+R0iT8kD+BLwVrD8KnANgJklm1lOdxUpIhFK2yJyMDLMbG6b9y+4+56hh7lmNo/IX/mXBOv+BbjfzP4NqAa+Gqy/HrjbzK4iciXgGiJPyBSRbqI+BCLS5YI+BOXuvjnsWkQkOrplICIiIrpCICIiIrpCICIiIigQiIiICAoEIiIiggKBiIiIoEAgIiIiKBCIiIgI8P8BwGbzVUlDYoEAAAAASUVORK5CYII=\n",
            "text/plain": [
              "<Figure size 576x432 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ya7x7gr9UjU0"
      },
      "source": [
        "Each model in this tutorial will use the same training configuration. So set these up in a reusable way, starting with the list of callbacks.\n",
        "\n",
        "The training for this tutorial runs for many short epochs. To reduce the logging noise use the `tfdocs.EpochDots` which simply prints a `.` for each epoch, and a full set of metrics every 100 epochs.\n",
        "\n",
        "Next include `callbacks.EarlyStopping` to avoid long and unnecessary training times. Note that this callback is set to monitor the `val_binary_crossentropy`, not the `val_loss`. This difference will be important later.\n",
        "\n",
        "Use `callbacks.TensorBoard` to generate TensorBoard logs for the training.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vSv8rfw_T85n"
      },
      "source": [
        "def get_callbacks(name):\n",
        "  return [\n",
        "    tfdocs.modeling.EpochDots(),\n",
        "    tf.keras.callbacks.EarlyStopping(monitor='val_binary_crossentropy', patience=200),\n",
        "    tf.keras.callbacks.TensorBoard(logdir/name),\n",
        "  ]"
      ],
      "execution_count": 17,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VhctzKhBWVDD"
      },
      "source": [
        "Similarly each model will use the same `Model.compile` and `Model.fit` settings:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xRCGwU3YH5sT"
      },
      "source": [
        "def compile_and_fit(model, name, optimizer=None, max_epochs=10000):\n",
        "  if optimizer is None:\n",
        "    optimizer = get_optimizer()\n",
        "  model.compile(optimizer=optimizer,\n",
        "                loss=tf.keras.losses.BinaryCrossentropy(from_logits=True),\n",
        "                metrics=[\n",
        "                  tf.keras.losses.BinaryCrossentropy(\n",
        "                      from_logits=True, name='binary_crossentropy'),\n",
        "                  'accuracy'])\n",
        "\n",
        "  model.summary()\n",
        "\n",
        "  history = model.fit(\n",
        "    train_ds,\n",
        "    steps_per_epoch = STEPS_PER_EPOCH,\n",
        "    epochs=max_epochs,\n",
        "    validation_data=validate_ds,\n",
        "    callbacks=get_callbacks(name),\n",
        "    verbose=0)\n",
        "  return history"
      ],
      "execution_count": 18,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mxBeiLUiWHJV"
      },
      "source": [
        "### Tiny model"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "a6JDv12scLTI"
      },
      "source": [
        "Start by training a model:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EZh-QFjKHb70"
      },
      "source": [
        "# Sequential groups a linear stack of layers into a tf.keras.Model\n",
        "# TODO\n",
        "tiny_model = tf.keras.Sequential([\n",
        "    layers.Dense(16, activation='elu', input_shape=(FEATURES,)),\n",
        "    layers.Dense(1)\n",
        "])"
      ],
      "execution_count": 19,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "X72IUdWYipIS"
      },
      "source": [
        "size_histories = {}"
      ],
      "execution_count": 20,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bdOcJtPGHhJ5",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1525262e-e864-45db-c038-2d0b47c88d42"
      },
      "source": [
        "size_histories['Tiny'] = compile_and_fit(tiny_model, 'sizes/Tiny')"
      ],
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"sequential\"\n",
            "_________________________________________________________________\n",
            "Layer (type)                 Output Shape              Param #   \n",
            "=================================================================\n",
            "dense (Dense)                (None, 16)                464       \n",
            "_________________________________________________________________\n",
            "dense_1 (Dense)              (None, 1)                 17        \n",
            "=================================================================\n",
            "Total params: 481\n",
            "Trainable params: 481\n",
            "Non-trainable params: 0\n",
            "_________________________________________________________________\n",
            "WARNING:tensorflow:Callback method `on_train_batch_begin` is slow compared to the batch time (batch time: 0.0053s vs `on_train_batch_begin` time: 0.0244s). Check your callbacks.\n",
            "WARNING:tensorflow:Callback method `on_train_batch_end` is slow compared to the batch time (batch time: 0.0053s vs `on_train_batch_end` time: 0.0194s). Check your callbacks.\n",
            "\n",
            "Epoch: 0, accuracy:0.4708,  binary_crossentropy:0.8323,  loss:0.8323,  val_accuracy:0.4610,  val_binary_crossentropy:0.7652,  val_loss:0.7652,  \n",
            "....................................................................................................\n",
            "Epoch: 100, accuracy:0.6031,  binary_crossentropy:0.6237,  loss:0.6237,  val_accuracy:0.5850,  val_binary_crossentropy:0.6264,  val_loss:0.6264,  \n",
            "....................................................................................................\n",
            "Epoch: 200, accuracy:0.6339,  binary_crossentropy:0.6099,  loss:0.6099,  val_accuracy:0.6090,  val_binary_crossentropy:0.6117,  val_loss:0.6117,  \n",
            "....................................................................................................\n",
            "Epoch: 300, accuracy:0.6519,  binary_crossentropy:0.6009,  loss:0.6009,  val_accuracy:0.6120,  val_binary_crossentropy:0.6052,  val_loss:0.6052,  \n",
            "....................................................................................................\n",
            "Epoch: 400, accuracy:0.6611,  binary_crossentropy:0.5938,  loss:0.5938,  val_accuracy:0.6160,  val_binary_crossentropy:0.5976,  val_loss:0.5976,  \n",
            "....................................................................................................\n",
            "Epoch: 500, accuracy:0.6642,  binary_crossentropy:0.5883,  loss:0.5883,  val_accuracy:0.6470,  val_binary_crossentropy:0.5926,  val_loss:0.5926,  \n",
            "....................................................................................................\n",
            "Epoch: 600, accuracy:0.6715,  binary_crossentropy:0.5849,  loss:0.5849,  val_accuracy:0.6480,  val_binary_crossentropy:0.5915,  val_loss:0.5915,  \n",
            "....................................................................................................\n",
            "Epoch: 700, accuracy:0.6752,  binary_crossentropy:0.5824,  loss:0.5824,  val_accuracy:0.6600,  val_binary_crossentropy:0.5912,  val_loss:0.5912,  \n",
            "....................................................................................................\n",
            "Epoch: 800, accuracy:0.6763,  binary_crossentropy:0.5797,  loss:0.5797,  val_accuracy:0.6520,  val_binary_crossentropy:0.5927,  val_loss:0.5927,  \n",
            "......................................................................."
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rS_QGT6icwdI"
      },
      "source": [
        "Now check how the model did:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dkEvb2x5XsjE",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 300
        },
        "outputId": "b978164a-e211-4d0d-87f6-a9fbb7cc34eb"
      },
      "source": [
        "plotter = tfdocs.plots.HistoryPlotter(metric = 'binary_crossentropy', smoothing_std=10)\n",
        "plotter.plot(size_histories)\n",
        "plt.ylim([0.5, 0.7])"
      ],
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(0.5, 0.7)"
            ]
          },
          "metadata": {},
          "execution_count": 22
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LGxGzh_FWOJ8"
      },
      "source": [
        "### Small model"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YjMb6E72f2pN"
      },
      "source": [
        "To see if you can beat the performance of the small model, progressively train some larger models.\n",
        "\n",
        "Try two hidden layers with 16 units each:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QKgdXPx9usBa"
      },
      "source": [
        "small_model = tf.keras.Sequential([\n",
        "    # `input_shape` is only required here so that `.summary` works.\n",
        "    layers.Dense(16, activation='elu', input_shape=(FEATURES,)),\n",
        "    layers.Dense(16, activation='elu'),\n",
        "    layers.Dense(1)\n",
        "])"
      ],
      "execution_count": 23,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LqG3MXF5xSjR",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ac4b117d-e3d9-4da3-b686-7a2e6fa5570b"
      },
      "source": [
        "size_histories['Small'] = compile_and_fit(small_model, 'sizes/Small')"
      ],
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"sequential_1\"\n",
            "_________________________________________________________________\n",
            "Layer (type)                 Output Shape              Param #   \n",
            "=================================================================\n",
            "dense_2 (Dense)              (None, 16)                464       \n",
            "_________________________________________________________________\n",
            "dense_3 (Dense)              (None, 16)                272       \n",
            "_________________________________________________________________\n",
            "dense_4 (Dense)              (None, 1)                 17        \n",
            "=================================================================\n",
            "Total params: 753\n",
            "Trainable params: 753\n",
            "Non-trainable params: 0\n",
            "_________________________________________________________________\n",
            "WARNING:tensorflow:Callback method `on_train_batch_begin` is slow compared to the batch time (batch time: 0.0047s vs `on_train_batch_begin` time: 0.0183s). Check your callbacks.\n",
            "WARNING:tensorflow:Callback method `on_train_batch_end` is slow compared to the batch time (batch time: 0.0047s vs `on_train_batch_end` time: 0.0198s). Check your callbacks.\n",
            "\n",
            "Epoch: 0, accuracy:0.4890,  binary_crossentropy:0.7270,  loss:0.7270,  val_accuracy:0.4590,  val_binary_crossentropy:0.7101,  val_loss:0.7101,  \n",
            "....................................................................................................\n",
            "Epoch: 100, accuracy:0.6127,  binary_crossentropy:0.6165,  loss:0.6165,  val_accuracy:0.6190,  val_binary_crossentropy:0.6214,  val_loss:0.6214,  \n",
            "....................................................................................................\n",
            "Epoch: 200, accuracy:0.6593,  binary_crossentropy:0.5921,  loss:0.5921,  val_accuracy:0.6700,  val_binary_crossentropy:0.5983,  val_loss:0.5983,  \n",
            "....................................................................................................\n",
            "Epoch: 300, accuracy:0.6760,  binary_crossentropy:0.5822,  loss:0.5822,  val_accuracy:0.6730,  val_binary_crossentropy:0.5929,  val_loss:0.5929,  \n",
            "....................................................................................................\n",
            "Epoch: 400, accuracy:0.6799,  binary_crossentropy:0.5752,  loss:0.5752,  val_accuracy:0.6810,  val_binary_crossentropy:0.5919,  val_loss:0.5919,  \n",
            "....................................................................................................\n",
            "Epoch: 500, accuracy:0.6852,  binary_crossentropy:0.5701,  loss:0.5701,  val_accuracy:0.6730,  val_binary_crossentropy:0.5944,  val_loss:0.5944,  \n",
            ".................................................................................................."
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "L-DGRBbGxI6G"
      },
      "source": [
        "### Medium model"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SrfoVQheYSO5"
      },
      "source": [
        "Now try 3 hidden layers with 64 units each:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jksi-XtaxDAh"
      },
      "source": [
        "medium_model = tf.keras.Sequential([\n",
        "    layers.Dense(64, activation='elu', input_shape=(FEATURES,)),\n",
        "    layers.Dense(64, activation='elu'),\n",
        "    layers.Dense(64, activation='elu'),\n",
        "    layers.Dense(1)\n",
        "])"
      ],
      "execution_count": 25,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jbngCZliYdma"
      },
      "source": [
        "And train the model using the same data:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ofn1AwDhx-Fe",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "8aa4df07-0e45-4c8a-93ae-52a2712ebcae"
      },
      "source": [
        "size_histories['Medium']  = compile_and_fit(medium_model, \"sizes/Medium\")"
      ],
      "execution_count": 26,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"sequential_2\"\n",
            "_________________________________________________________________\n",
            "Layer (type)                 Output Shape              Param #   \n",
            "=================================================================\n",
            "dense_5 (Dense)              (None, 64)                1856      \n",
            "_________________________________________________________________\n",
            "dense_6 (Dense)              (None, 64)                4160      \n",
            "_________________________________________________________________\n",
            "dense_7 (Dense)              (None, 64)                4160      \n",
            "_________________________________________________________________\n",
            "dense_8 (Dense)              (None, 1)                 65        \n",
            "=================================================================\n",
            "Total params: 10,241\n",
            "Trainable params: 10,241\n",
            "Non-trainable params: 0\n",
            "_________________________________________________________________\n",
            "WARNING:tensorflow:Callback method `on_train_batch_begin` is slow compared to the batch time (batch time: 0.0047s vs `on_train_batch_begin` time: 0.0174s). Check your callbacks.\n",
            "WARNING:tensorflow:Callback method `on_train_batch_end` is slow compared to the batch time (batch time: 0.0047s vs `on_train_batch_end` time: 0.0219s). Check your callbacks.\n",
            "\n",
            "Epoch: 0, accuracy:0.5040,  binary_crossentropy:0.6909,  loss:0.6909,  val_accuracy:0.5240,  val_binary_crossentropy:0.6697,  val_loss:0.6697,  \n",
            "....................................................................................................\n",
            "Epoch: 100, accuracy:0.7164,  binary_crossentropy:0.5288,  loss:0.5288,  val_accuracy:0.6570,  val_binary_crossentropy:0.6201,  val_loss:0.6201,  \n",
            "....................................................................................................\n",
            "Epoch: 200, accuracy:0.7820,  binary_crossentropy:0.4357,  loss:0.4357,  val_accuracy:0.6320,  val_binary_crossentropy:0.7294,  val_loss:0.7294,  \n",
            "........................................................"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vIPuf23FFaVn"
      },
      "source": [
        "### Large model\n",
        "\n",
        "As an exercise, you can create an even larger model, and see how quickly it begins overfitting.  Next, let's add to this benchmark a network that has much more capacity, far more than the problem would warrant:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ghQwwqwqvQM9"
      },
      "source": [
        "large_model = tf.keras.Sequential([\n",
        "    layers.Dense(512, activation='elu', input_shape=(FEATURES,)),\n",
        "    layers.Dense(512, activation='elu'),\n",
        "    layers.Dense(512, activation='elu'),\n",
        "    layers.Dense(512, activation='elu'),\n",
        "    layers.Dense(1)\n",
        "])"
      ],
      "execution_count": 27,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "D-d-i5DaYmr7"
      },
      "source": [
        "And, again, train the model using the same data:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "U1A99dhqvepf",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "348affcf-a172-4ce5-b288-bd02be6a372c"
      },
      "source": [
        "size_histories['large'] = compile_and_fit(large_model, \"sizes/large\")"
      ],
      "execution_count": 28,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"sequential_3\"\n",
            "_________________________________________________________________\n",
            "Layer (type)                 Output Shape              Param #   \n",
            "=================================================================\n",
            "dense_9 (Dense)              (None, 512)               14848     \n",
            "_________________________________________________________________\n",
            "dense_10 (Dense)             (None, 512)               262656    \n",
            "_________________________________________________________________\n",
            "dense_11 (Dense)             (None, 512)               262656    \n",
            "_________________________________________________________________\n",
            "dense_12 (Dense)             (None, 512)               262656    \n",
            "_________________________________________________________________\n",
            "dense_13 (Dense)             (None, 1)                 513       \n",
            "=================================================================\n",
            "Total params: 803,329\n",
            "Trainable params: 803,329\n",
            "Non-trainable params: 0\n",
            "_________________________________________________________________\n",
            "WARNING:tensorflow:Callback method `on_train_batch_begin` is slow compared to the batch time (batch time: 0.0055s vs `on_train_batch_begin` time: 0.0174s). Check your callbacks.\n",
            "WARNING:tensorflow:Callback method `on_train_batch_end` is slow compared to the batch time (batch time: 0.0055s vs `on_train_batch_end` time: 0.0235s). Check your callbacks.\n",
            "\n",
            "Epoch: 0, accuracy:0.5044,  binary_crossentropy:0.8358,  loss:0.8358,  val_accuracy:0.5330,  val_binary_crossentropy:0.6740,  val_loss:0.6740,  \n",
            "....................................................................................................\n",
            "Epoch: 100, accuracy:1.0000,  binary_crossentropy:0.0023,  loss:0.0023,  val_accuracy:0.6390,  val_binary_crossentropy:1.8497,  val_loss:1.8497,  \n",
            "....................................................................................................\n",
            "Epoch: 200, accuracy:1.0000,  binary_crossentropy:0.0001,  loss:0.0001,  val_accuracy:0.6430,  val_binary_crossentropy:2.5375,  val_loss:2.5375,  \n",
            "..................."
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Fy3CMUZpzH3d"
      },
      "source": [
        "### Plot the training and validation losses"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HSlo1F4xHuuM"
      },
      "source": [
        "The solid lines show the training loss, and the dashed lines show the validation loss (remember: a lower validation loss indicates a better model)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OLhL1AszdLfM"
      },
      "source": [
        "While building a larger model gives it more power, if this power is not constrained somehow it can easily overfit to the training set.\n",
        "\n",
        "In this example, typically, only the `\"Tiny\"` model manages to avoid overfitting altogether, and each of the larger models overfit the data more quickly. This becomes so severe for the `\"large\"` model that you need to switch the plot to a log-scale to really see what's happening.\n",
        "\n",
        "This is apparent if you plot and compare the validation metrics to the training metrics.\n",
        "\n",
        "* It's normal for there to be a small difference.\n",
        "* If both metrics are moving in the same direction, everything is fine.\n",
        "* If the validation metric begins to stagnate while the training metric continues to improve, you are probably close to overfitting.\n",
        "* If the validation metric is going in the wrong direction, the model is clearly overfitting."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0XmKDtOWzOpk",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 304
        },
        "outputId": "8e464afd-bd3d-46e0-85bf-b1870bd1d872"
      },
      "source": [
        "plotter.plot(size_histories)\n",
        "a = plt.xscale('log')\n",
        "plt.xlim([5, max(plt.xlim())])\n",
        "plt.ylim([0.5, 0.7])\n",
        "plt.xlabel(\"Epochs [Log Scale]\")"
      ],
      "execution_count": 29,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Text(0.5, 0, 'Epochs [Log Scale]')"
            ]
          },
          "metadata": {},
          "execution_count": 29
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UekcaQdmZxnW"
      },
      "source": [
        "Note: All the above training runs used the `callbacks.EarlyStopping` to end the training once it was clear the model was not making progress."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ASdv7nsgEFhx"
      },
      "source": [
        "## Strategies to prevent overfitting"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YN512ksslaxJ"
      },
      "source": [
        "Before getting into the content of this section copy the training logs from the `\"Tiny\"` model above, to use as a baseline for comparison."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "40k1eBtnQzNo",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "19d61042-0448-45ad-d5bf-cdc89e887ad0"
      },
      "source": [
        "shutil.rmtree(logdir/'regularizers/Tiny', ignore_errors=True)\n",
        "shutil.copytree(logdir/'sizes/Tiny', logdir/'regularizers/Tiny')"
      ],
      "execution_count": 32,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "PosixPath('/tmp/tmpzhv_3dha/tensorboard_logs/regularizers/Tiny')"
            ]
          },
          "metadata": {},
          "execution_count": 32
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vFWMeFo7jLpN"
      },
      "source": [
        "regularizer_histories = {}\n",
        "regularizer_histories['Tiny'] = size_histories['Tiny']"
      ],
      "execution_count": 33,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4rHoVWcswFLa"
      },
      "source": [
        "### Add weight regularization\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kRxWepNawbBK"
      },
      "source": [
        "You may be familiar with Occam's Razor principle: given two explanations for something, the explanation most likely to be correct is the \"simplest\" one, the one that makes the least amount of assumptions. This also applies to the models learned by neural networks: given some training data and a network architecture, there are multiple sets of weights values (multiple models) that could explain the data, and simpler models are less likely to overfit than complex ones.\n",
        "\n",
        "A \"simple model\" in this context is a model where the distribution of parameter values has less entropy (or a model with fewer parameters altogether, as we saw in the section above). Thus a common way to mitigate overfitting is to put constraints on the complexity of a network by forcing its weights only to take small values, which makes the distribution of weight values more \"regular\". This is called \"weight regularization\", and it is done by adding to the loss function of the network a cost associated with having large weights. This cost comes in two flavors:\n",
        "\n",
        "* [L1 regularization](https://developers.google.com/machine-learning/glossary/#L1_regularization), where the cost added is proportional to the absolute value of the weights coefficients (i.e. to what is called the \"L1 norm\" of the weights).\n",
        "\n",
        "* [L2 regularization](https://developers.google.com/machine-learning/glossary/#L2_regularization), where the cost added is proportional to the square of the value of the weights coefficients (i.e. to what is called the squared \"L2 norm\" of the weights). L2 regularization is also called weight decay in the context of neural networks. Don't let the different name confuse you: weight decay is mathematically the exact same as L2 regularization.\n",
        "\n",
        "L1 regularization pushes weights towards exactly zero encouraging a sparse model. L2 regularization will penalize the weights parameters without making them sparse since the penalty goes to zero for small weights-one reason why L2 is more common.\n",
        "\n",
        "In `tf.keras`, weight regularization is added by passing weight regularizer instances to layers as keyword arguments. Let's add L2 weight regularization now."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HFGmcwduwVyQ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "54a53ad9-1151-4e69-ce4b-681a43e6e3e6"
      },
      "source": [
        "l2_model = tf.keras.Sequential([\n",
        "    layers.Dense(512, activation='elu',\n",
        "                 kernel_regularizer=regularizers.l2(0.001),\n",
        "                 input_shape=(FEATURES,)),\n",
        "    layers.Dense(512, activation='elu',\n",
        "                 kernel_regularizer=regularizers.l2(0.001)),\n",
        "    layers.Dense(512, activation='elu',\n",
        "                 kernel_regularizer=regularizers.l2(0.001)),\n",
        "    layers.Dense(512, activation='elu',\n",
        "                 kernel_regularizer=regularizers.l2(0.001)),\n",
        "    layers.Dense(1)\n",
        "])\n",
        "\n",
        "regularizer_histories['l2'] = compile_and_fit(l2_model, \"regularizers/l2\")"
      ],
      "execution_count": 34,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"sequential_4\"\n",
            "_________________________________________________________________\n",
            "Layer (type)                 Output Shape              Param #   \n",
            "=================================================================\n",
            "dense_14 (Dense)             (None, 512)               14848     \n",
            "_________________________________________________________________\n",
            "dense_15 (Dense)             (None, 512)               262656    \n",
            "_________________________________________________________________\n",
            "dense_16 (Dense)             (None, 512)               262656    \n",
            "_________________________________________________________________\n",
            "dense_17 (Dense)             (None, 512)               262656    \n",
            "_________________________________________________________________\n",
            "dense_18 (Dense)             (None, 1)                 513       \n",
            "=================================================================\n",
            "Total params: 803,329\n",
            "Trainable params: 803,329\n",
            "Non-trainable params: 0\n",
            "_________________________________________________________________\n",
            "WARNING:tensorflow:Callback method `on_train_batch_begin` is slow compared to the batch time (batch time: 0.0071s vs `on_train_batch_begin` time: 0.0180s). Check your callbacks.\n",
            "WARNING:tensorflow:Callback method `on_train_batch_end` is slow compared to the batch time (batch time: 0.0071s vs `on_train_batch_end` time: 0.0248s). Check your callbacks.\n",
            "\n",
            "Epoch: 0, accuracy:0.5001,  binary_crossentropy:0.7630,  loss:2.2603,  val_accuracy:0.4880,  val_binary_crossentropy:0.6807,  val_loss:2.0898,  \n",
            "....................................................................................................\n",
            "Epoch: 100, accuracy:0.6571,  binary_crossentropy:0.6011,  loss:0.6235,  val_accuracy:0.6400,  val_binary_crossentropy:0.5825,  val_loss:0.6046,  \n",
            "....................................................................................................\n",
            "Epoch: 200, accuracy:0.6665,  binary_crossentropy:0.5845,  loss:0.6073,  val_accuracy:0.7010,  val_binary_crossentropy:0.5753,  val_loss:0.5986,  \n",
            "....................................................................................................\n",
            "Epoch: 300, accuracy:0.6787,  binary_crossentropy:0.5760,  loss:0.6002,  val_accuracy:0.6750,  val_binary_crossentropy:0.5721,  val_loss:0.5962,  \n",
            "....................................................................................................\n",
            "Epoch: 400, accuracy:0.6888,  binary_crossentropy:0.5666,  loss:0.5911,  val_accuracy:0.6770,  val_binary_crossentropy:0.5689,  val_loss:0.5933,  \n",
            "....................................................................................................\n",
            "Epoch: 500, accuracy:0.6952,  binary_crossentropy:0.5605,  loss:0.5870,  val_accuracy:0.6800,  val_binary_crossentropy:0.5730,  val_loss:0.5995,  \n",
            "..............................................................................."
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bUUHoXb7w-_C"
      },
      "source": [
        "`l2(0.001)` means that every coefficient in the weight matrix of the layer will add `0.001 * weight_coefficient_value**2` to the total **loss** of the network.\n",
        "\n",
        "That is why we're monitoring the `binary_crossentropy` directly. Because it doesn't have this regularization component mixed in.\n",
        "\n",
        "So, that same `\"Large\"` model with an `L2` regularization penalty performs much better:\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7wkfLyxBZdh_",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 300
        },
        "outputId": "79fd9936-8f4d-4e66-d551-b3896563ae85"
      },
      "source": [
        "plotter.plot(regularizer_histories)\n",
        "plt.ylim([0.5, 0.7])"
      ],
      "execution_count": 35,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(0.5, 0.7)"
            ]
          },
          "metadata": {},
          "execution_count": 35
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Kx1YHMsVxWjP"
      },
      "source": [
        "As you can see, the `\"L2\"` regularized model is now much more competitive with the the `\"Tiny\"` model. This `\"L2\"` model is also much more resistant to overfitting than the `\"Large\"` model it was based on despite having the same number of parameters."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JheBk6f8jMQ7"
      },
      "source": [
        "#### More info\n",
        "\n",
        "There are two important things to note about this sort of regularization.\n",
        "\n",
        "**First:** if you are writing your own training loop, then you need to be sure to ask the model for its regularization losses."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "apDHQNybjaML"
      },
      "source": [
        "result = l2_model(features)\n",
        "regularization_loss=tf.add_n(l2_model.losses)"
      ],
      "execution_count": 36,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MLhG6fMSjE-J"
      },
      "source": [
        "**Second:** This implementation works by adding the weight penalties to the model's loss, and then applying a standard optimization procedure after that.\n",
        "\n",
        "There is a second approach that instead only runs the optimizer on the raw loss, and then while applying the calculated step the optimizer also applies some weight decay. This \"Decoupled Weight Decay\" is seen in optimizers like `optimizers.FTRL` and `optimizers.AdamW`."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HmnBNOOVxiG8"
      },
      "source": [
        "### Add dropout\n",
        "\n",
        "Dropout is one of the most effective and most commonly used regularization techniques for neural networks, developed by Hinton and his students at the University of Toronto.\n",
        "\n",
        "The intuitive explanation for dropout is that because individual nodes in the network cannot rely on the output of the others, each node must output features that are useful on their own.\n",
        "\n",
        "Dropout, applied to a layer, consists of randomly \"dropping out\" (i.e. set to zero) a number of output features of the layer during training. Let's say a given layer would normally have returned a vector [0.2, 0.5, 1.3, 0.8, 1.1] for a given input sample during training; after applying dropout, this vector will have a few zero entries distributed at random, e.g. [0, 0.5,\n",
        "1.3, 0, 1.1].\n",
        "\n",
        "The \"dropout rate\" is the fraction of the features that are being zeroed-out; it is usually set between 0.2 and 0.5. At test time, no units are dropped out, and instead the layer's output values are scaled down by a factor equal to the dropout rate, so as to balance for the fact that more units are active than at training time.\n",
        "\n",
        "In `tf.keras` you can introduce dropout in a network via the Dropout layer, which gets applied to the output of layer right before.\n",
        "\n",
        "Let's add two Dropout layers in our network to see how well they do at reducing overfitting:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OFEYvtrHxSWS",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "6a8da541-e6df-4c8a-e00f-a7f36dc077bc"
      },
      "source": [
        "dropout_model = tf.keras.Sequential([\n",
        "    layers.Dense(512, activation='elu', input_shape=(FEATURES,)),\n",
        "    layers.Dropout(0.5),\n",
        "    layers.Dense(512, activation='elu'),\n",
        "    layers.Dropout(0.5),\n",
        "    layers.Dense(512, activation='elu'),\n",
        "    layers.Dropout(0.5),\n",
        "    layers.Dense(512, activation='elu'),\n",
        "    layers.Dropout(0.5),\n",
        "    layers.Dense(1)\n",
        "])\n",
        "\n",
        "regularizer_histories['dropout'] = compile_and_fit(dropout_model, \"regularizers/dropout\")"
      ],
      "execution_count": 37,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"sequential_5\"\n",
            "_________________________________________________________________\n",
            "Layer (type)                 Output Shape              Param #   \n",
            "=================================================================\n",
            "dense_19 (Dense)             (None, 512)               14848     \n",
            "_________________________________________________________________\n",
            "dropout (Dropout)            (None, 512)               0         \n",
            "_________________________________________________________________\n",
            "dense_20 (Dense)             (None, 512)               262656    \n",
            "_________________________________________________________________\n",
            "dropout_1 (Dropout)          (None, 512)               0         \n",
            "_________________________________________________________________\n",
            "dense_21 (Dense)             (None, 512)               262656    \n",
            "_________________________________________________________________\n",
            "dropout_2 (Dropout)          (None, 512)               0         \n",
            "_________________________________________________________________\n",
            "dense_22 (Dense)             (None, 512)               262656    \n",
            "_________________________________________________________________\n",
            "dropout_3 (Dropout)          (None, 512)               0         \n",
            "_________________________________________________________________\n",
            "dense_23 (Dense)             (None, 1)                 513       \n",
            "=================================================================\n",
            "Total params: 803,329\n",
            "Trainable params: 803,329\n",
            "Non-trainable params: 0\n",
            "_________________________________________________________________\n",
            "WARNING:tensorflow:Callback method `on_train_batch_begin` is slow compared to the batch time (batch time: 0.0061s vs `on_train_batch_begin` time: 0.0172s). Check your callbacks.\n",
            "WARNING:tensorflow:Callback method `on_train_batch_end` is slow compared to the batch time (batch time: 0.0061s vs `on_train_batch_end` time: 0.0247s). Check your callbacks.\n",
            "\n",
            "Epoch: 0, accuracy:0.5116,  binary_crossentropy:0.7974,  loss:0.7974,  val_accuracy:0.5450,  val_binary_crossentropy:0.6694,  val_loss:0.6694,  \n",
            "....................................................................................................\n",
            "Epoch: 100, accuracy:0.6509,  binary_crossentropy:0.5968,  loss:0.5968,  val_accuracy:0.6910,  val_binary_crossentropy:0.5698,  val_loss:0.5698,  \n",
            "....................................................................................................\n",
            "Epoch: 200, accuracy:0.6884,  binary_crossentropy:0.5560,  loss:0.5560,  val_accuracy:0.6960,  val_binary_crossentropy:0.5873,  val_loss:0.5873,  \n",
            "....................................................................................................\n",
            "Epoch: 300, accuracy:0.7263,  binary_crossentropy:0.5043,  loss:0.5043,  val_accuracy:0.6940,  val_binary_crossentropy:0.5986,  val_loss:0.5986,  \n",
            ".."
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SPZqwVchx5xp",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 300
        },
        "outputId": "1e13538b-d2fe-450d-91a7-86f9112a84cb"
      },
      "source": [
        "plotter.plot(regularizer_histories)\n",
        "plt.ylim([0.5, 0.7])"
      ],
      "execution_count": 38,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(0.5, 0.7)"
            ]
          },
          "metadata": {},
          "execution_count": 38
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4zlHr4iaI1U6"
      },
      "source": [
        "It's clear from this plot that both of these regularization approaches improve the behavior of the `\"Large\"` model. But this still doesn't beat even the `\"Tiny\"` baseline.\n",
        "\n",
        "Next try them both, together, and see if that does better."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "u7qMg_7Nwy5t"
      },
      "source": [
        "### Combined L2 + dropout"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7zfs_qQIw1cz",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f7c6e8ea-b815-438d-eaa4-973aad97c68f"
      },
      "source": [
        "combined_model = tf.keras.Sequential([\n",
        "    layers.Dense(512, kernel_regularizer=regularizers.l2(0.0001),\n",
        "                 activation='elu', input_shape=(FEATURES,)),\n",
        "    layers.Dropout(0.5),\n",
        "    layers.Dense(512, kernel_regularizer=regularizers.l2(0.0001),\n",
        "                 activation='elu'),\n",
        "    layers.Dropout(0.5),\n",
        "    layers.Dense(512, kernel_regularizer=regularizers.l2(0.0001),\n",
        "                 activation='elu'),\n",
        "    layers.Dropout(0.5),\n",
        "    layers.Dense(512, kernel_regularizer=regularizers.l2(0.0001),\n",
        "                 activation='elu'),\n",
        "    layers.Dropout(0.5),\n",
        "    layers.Dense(1)\n",
        "])\n",
        "\n",
        "regularizer_histories['combined'] = compile_and_fit(combined_model, \"regularizers/combined\")"
      ],
      "execution_count": 39,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"sequential_6\"\n",
            "_________________________________________________________________\n",
            "Layer (type)                 Output Shape              Param #   \n",
            "=================================================================\n",
            "dense_24 (Dense)             (None, 512)               14848     \n",
            "_________________________________________________________________\n",
            "dropout_4 (Dropout)          (None, 512)               0         \n",
            "_________________________________________________________________\n",
            "dense_25 (Dense)             (None, 512)               262656    \n",
            "_________________________________________________________________\n",
            "dropout_5 (Dropout)          (None, 512)               0         \n",
            "_________________________________________________________________\n",
            "dense_26 (Dense)             (None, 512)               262656    \n",
            "_________________________________________________________________\n",
            "dropout_6 (Dropout)          (None, 512)               0         \n",
            "_________________________________________________________________\n",
            "dense_27 (Dense)             (None, 512)               262656    \n",
            "_________________________________________________________________\n",
            "dropout_7 (Dropout)          (None, 512)               0         \n",
            "_________________________________________________________________\n",
            "dense_28 (Dense)             (None, 1)                 513       \n",
            "=================================================================\n",
            "Total params: 803,329\n",
            "Trainable params: 803,329\n",
            "Non-trainable params: 0\n",
            "_________________________________________________________________\n",
            "WARNING:tensorflow:Callback method `on_train_batch_begin` is slow compared to the batch time (batch time: 0.0072s vs `on_train_batch_begin` time: 0.0176s). Check your callbacks.\n",
            "WARNING:tensorflow:Callback method `on_train_batch_end` is slow compared to the batch time (batch time: 0.0072s vs `on_train_batch_end` time: 0.0265s). Check your callbacks.\n",
            "\n",
            "Epoch: 0, accuracy:0.5030,  binary_crossentropy:0.7917,  loss:0.9501,  val_accuracy:0.5260,  val_binary_crossentropy:0.6847,  val_loss:0.8424,  \n",
            "....................................................................................................\n",
            "Epoch: 100, accuracy:0.6467,  binary_crossentropy:0.6033,  loss:0.6331,  val_accuracy:0.6440,  val_binary_crossentropy:0.5842,  val_loss:0.6139,  \n",
            "....................................................................................................\n",
            "Epoch: 200, accuracy:0.6647,  binary_crossentropy:0.5871,  loss:0.6138,  val_accuracy:0.6740,  val_binary_crossentropy:0.5710,  val_loss:0.5977,  \n",
            "....................................................................................................\n",
            "Epoch: 300, accuracy:0.6712,  binary_crossentropy:0.5810,  loss:0.6098,  val_accuracy:0.6890,  val_binary_crossentropy:0.5611,  val_loss:0.5899,  \n",
            "....................................................................................................\n",
            "Epoch: 400, accuracy:0.6744,  binary_crossentropy:0.5760,  loss:0.6065,  val_accuracy:0.6680,  val_binary_crossentropy:0.5675,  val_loss:0.5981,  \n",
            "....................................................................................................\n",
            "Epoch: 500, accuracy:0.6839,  binary_crossentropy:0.5710,  loss:0.6033,  val_accuracy:0.6840,  val_binary_crossentropy:0.5528,  val_loss:0.5852,  \n",
            "....................................................................................................\n",
            "Epoch: 600, accuracy:0.6814,  binary_crossentropy:0.5681,  loss:0.6024,  val_accuracy:0.7040,  val_binary_crossentropy:0.5473,  val_loss:0.5815,  \n",
            "....................................................................................................\n",
            "Epoch: 700, accuracy:0.6884,  binary_crossentropy:0.5614,  loss:0.5971,  val_accuracy:0.7020,  val_binary_crossentropy:0.5377,  val_loss:0.5733,  \n",
            "....................................................................................................\n",
            "Epoch: 800, accuracy:0.6834,  binary_crossentropy:0.5626,  loss:0.5997,  val_accuracy:0.7040,  val_binary_crossentropy:0.5462,  val_loss:0.5833,  \n",
            "....................................................................................................\n",
            "Epoch: 900, accuracy:0.6977,  binary_crossentropy:0.5575,  loss:0.5959,  val_accuracy:0.6920,  val_binary_crossentropy:0.5434,  val_loss:0.5819,  \n",
            "."
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qDqBBxfI0Yd8",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 300
        },
        "outputId": "88927458-e117-498c-9a05-5a7c4d3c85db"
      },
      "source": [
        "# TODO\n",
        "plotter.plot(regularizer_histories)\n",
        "plt.ylim([0.5, 0.7])"
      ],
      "execution_count": 40,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(0.5, 0.7)"
            ]
          },
          "metadata": {},
          "execution_count": 40
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tE0OoNCQNTJv"
      },
      "source": [
        "This model with the `\"Combined\"` regularization is obviously the best one so far."
      ]
    }
  ]
}
